package com.xichen.controller;

import com.xichen.entity.*;
import com.xichen.pojo.User;
import com.xichen.pojo.UserRole;
import com.xichen.service.UserRoleService;
import com.xichen.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author tang wei
 * @version 1.0
 * @date 2020/7/16 10:16
 */
@RestController
@RequestMapping("/user")
public class UserController {
    //注入用户Service
    @Autowired
    private UserService userService;
    //注入用户权限Service
    @Autowired
    private UserRoleService userRoleService;

    /**
     * 用户登录
     *
     * @return 封装的结果类
     */
    @RequestMapping("/login")
    public Result login(User user, @RequestParam() String cold, HttpServletRequest request) {
        //从session中将存储的验证码取出
        String sessionCold = (String) request.getSession().getAttribute("CHECKCODE_SERVER");
        //取出的验证码与输入的验证码做对比，若是正确放行，不正确返回错误信息
        if (!cold.equalsIgnoreCase(sessionCold)) {
            return new Result(false, StatusCode.LOGINERROR, "验证码输入错误");
        }
        //判断cold是否为空
        if (cold == null || cold.equals("")) {
            return new Result(false, StatusCode.LOGINERROR, "请输入验证码");
        }
        //用输入的用户名查找用户信息
        String loginName = user.getLoginName();
        //判断输入的用户名信息是否为空，为空则返回错误信息
        if (loginName == null || loginName.equals("")) {
            return new Result(false, StatusCode.LOGINERROR, "请输入用户名");
        }
        //返回一个用户对象
        User u = userService.findUserByLoginName(loginName);
        //判断返回的对象是否为空
        if (u != null) {
            //不为空且两者用户名一致，登录成功
            if (u.getPwd().equals(user.getPwd())) {
                //将用户的信息存储在session中，方便用户名的回显
                request.getSession().setAttribute("user", u);
                //将session中的验证码进行删除
                request.getSession().removeAttribute("CHECKCODE_SERVER");
                //返回登录成功的信息
                return new Result(true, StatusCode.OK, "登录成功");
            } else {
                //密码不一致，返回错误信息
                return new Result(false, StatusCode.LOGINERROR, "输入的用户名密码错误");
            }
        } else {
            //查找的数据为空，返回错误信息
            return new Result(false, StatusCode.LOGINERROR, "输入的用户名不存在");
        }
    }

    /**
     * 获取用户名，再将日期传入前端
     *
     * @param request
     * @return
     */
    @RequestMapping("/getLoginUsername")
    public Result getLoginUsername(HttpServletRequest request) {
        //定义封装数据的Map
        Map<String, Object> map = new HashMap<>();
        //从session取出用户名
        User user = (User) request.getSession().getAttribute("user");
        //若是没有从session中取出数据，则判断其为未登录
        if (user == null) {
            return new Result(false, StatusCode.ERROR, "未登录，请先登录");
        }
        //将当前时间解析成字符串
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String dateTime = sdf.format(date);
        //获取当前用户权限所对应的菜单
        List<UserRole> menuList = userRoleService.findUserRole(user.getUserRole());
        //向map中传入姓名
        map.put("username", user.getUsername());
        //向map中传入日期
        map.put("dateTime", dateTime);
        //向map中传入动态菜单对象
        map.put("menuList", menuList);
        //返回结果
        return new Result(true, StatusCode.OK, "查找成功", map);
    }

    /**
     * 分页查询用户
     *
     * @param queryPageBean
     * @return
     */
    @RequestMapping("/findUserPage")
    public PageResult findUserPage(@RequestBody QueryPageBean queryPageBean) {
        //调用分页查询用户的方法
        return userService.findUserPage(queryPageBean);
    }

    /**
     * 通过用户名查找用户
     *
     * @param loginName
     * @return
     */
    @RequestMapping("/findUserByLoginName")
    public Result findUserByLoginName(String loginName) {
        //调用方法查找，通过用户名
        User user = userService.findUserByLoginName(loginName);
        //不等于null，返回查找成功
        if (user != null) {
            return new Result(true, StatusCode.OK, "查找成功");
        } else {
            //等于null，返回查找失败
            return new Result(false, StatusCode.ERROR, "查找失败");
        }
    }

    /**
     * 添加用户
     *
     * @param user
     * @return
     */
    @RequestMapping("/add")
    public Result add(@RequestBody User user) {
        //添加用户成功，返回成功信息。
        try {
            //封装添加时间
            user.setCreateTime(new Date());
            //封装修改时间
            user.setUpdateTime(new Date());
            //封装用户权限
            user.setUserRole(0);
            //添加
            userService.add(user);
            return new Result(true, StatusCode.OK, "添加成功");
        } catch (Exception e) {
            //出现异常，返回添加失败信息
            return new Result(false, StatusCode.ERROR, "添加失败，请检查输入的信息是否正确");
        }
    }

    /**
     * 通过id查找用户名
     *
     * @param id
     * @return
     */
    @RequestMapping("/findUserById")
    public Result findUserById(Long id) {
        //查找用户，通过id
        User user = userService.findUserById(id);
        if (user != null) {
            //找到返回
            return new Result(true, StatusCode.OK, "查找成功", user);
        }
        //没找到返回
        return new Result(false, StatusCode.ERROR, "查找用户信息失败");
    }

    /**
     * 通过用户名且不等于此id进行查找
     *
     * @param loginName
     * @param id
     * @return
     */
    @RequestMapping("/findUserByLoginNameAndNotEqualId")
    public Result findUserByLoginNameAndNotEqualId(String loginName, Long id) {
        //调用方法查找，通过用户名查找且不等于此id
        User user = userService.findUserByLoginNameAndNotEqualId(loginName, id);
        //不等于null，返回查找成功
        if (user != null) {
            return new Result(true, StatusCode.OK, "查找成功");
        } else {
            //等于null，返回查找失败
            return new Result(false, StatusCode.ERROR, "查找失败");
        }
    }

    /**
     * 修改用户信息
     *
     * @param user
     * @return
     */
    @RequestMapping("/update")
    public Result update(@RequestBody User user) {
        //修改用户成功，返回成功信息。
        try {
            //封装修改时间
            user.setUpdateTime(new Date());
            //添加
            userService.update(user);
            return new Result(true, StatusCode.OK, "修改成功");
        } catch (Exception e) {
            //出现异常，返回添加失败信息
            return new Result(false, StatusCode.ERROR, "修改失败，请检查输入的信息是否正确");
        }
    }

    /**
     * 删除用户
     */
    @RequestMapping("/delete")
    public Result delete(Long id) {
        //删除用户成功，返回成功信息。
        try {
            userService.delete(id);
            return new Result(true, StatusCode.OK, "删除成功");
        } catch (Exception e) {
            //出现异常，返回删除失败信息
            return new Result(false, StatusCode.ERROR, "删除失败");
        }
    }

    /**
     * 删除选中用户
     *
     * @param users
     * @return
     */
    @RequestMapping("/delSelect")
    public Result delSelect(List<User> users) {
        try {
            for (User user : users) {
                delete(user.getId());
            }
            return new Result(true, StatusCode.OK, "删除成功");
        } catch (Exception e) {
            return new Result(false, StatusCode.ERROR, "删除失败");
        }
    }

    /**
     * 用户退出系统
     * @param request
     */
    @RequestMapping("/exit")
    public void exit(HttpServletRequest request) {
        HttpSession session = request.getSession();
        session.removeAttribute("user");
    }
}
